package com.zhangxx.web.common.util;

import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;

/**
 * Redis工具类 <BR>
 * 需要使用redis时，RedisUtil <BR>
 * 例如：<BR>@Autowired <BR>
 * private RedisUtil redisUtil;
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;


    /**
     * 设置String，默认时间1天过期
     *
     * @param key   redis_key
     * @param value 设置的值
     */
    public void setString(String key, String value) {
        // String类型数据存储，设置过期时间为86400秒，采用TimeUnit控制时间单位
        getValueOperations().set(key, value, 86400, TimeUnit.SECONDS);
    }

    /**
     * 设置String
     *
     * @param key   redis_key
     * @param value 设置的值
     * @param time  过期时间,单位：秒

     */
    public void setString(String key, String value, long time) {
        getValueOperations().set(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 获取String值
     *
     * @param key redis_key
     * @return redis值

     */
    public String getString(String key) {
        return getValueOperations().get(key);
    }


    /**
     * 根据key获取过期时间
     *
     * @param key redis_Key
     * @return long 过期时间(单位:秒)

     */
    public long getExpireTime(String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 根据key删除缓存
     *
     * @param key redis_Key

     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 检查key是否存在
     *
     * @param key redis_Key
     * @return boolean 存在返回true, 反之返回false
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 判断key值是否存在，存在则不存储，不存在则存储
     *
     * @param key   key值
     * @param value 需要存储的值
     */
    public void setIfAbsent(String key, String value) {
        getValueOperations().setIfAbsent(key, value);
    }

    public ValueOperations<String, String> getValueOperations() {
        return redisTemplate.opsForValue();
    }



    /**
     * 列表数据key是否存在,如果返回true,说明有缓存,则可以根据member用为key,到缓存中获取
     *
     * @param key
     *            关键字
     * @param member
     *            条件组合key,如(cid:1-order:tt)

     */
    public  boolean listKeyExists(String key, String member) {
        ZSetOperations<String, String> zset = redisTemplate.opsForZSet();

        Long index = zset.rank(key, member);
            if (index != null) {

                zset.incrementScore(key, member, 1);// 如果在名称为key的zset中已经存在元素member，则该元素的score增加increment
                return true;
            }

        return false;
    }

    /**
     * 列表数据member如果在缓存中不存在,则根据情况存储到缓存中,如果返回true,说明已存储,则可以根据member作为key,将值存入缓存中
     *
     * @param key
     *            关键字
     * @param member
     *            条件组合key,如(cid:1-order:tt)

     */
    public  boolean listSetKey(String key, String member) {

        ZSetOperations<String, String> zset = redisTemplate.opsForZSet();
        Long count=86400L;
        int seconds=86400;
        // 获取当前存储值数量
            Long index = zset.zCard(key);
        // 当前最大存储空间足够时,存入新的内容
            if (index < count) {
                zset.add(key, member, 0);
                if (index == 0) { //设置过期时间
                    redisTemplate.expire(key,seconds,TimeUnit.SECONDS);
                }
                return true;
            }else{
                //删除当前访问频率少的记录
                if(zset.removeRangeByScore(key, 0, 1)>0){
                    zset.add(key, member, 0);
                    return true;
                }else{//未删除
                    return false;
                }
            }


    }


}
